const express = require('express');
const router = express.Router();
const { body, query, param, validationResult } = require('express-validator');
const Translation = require('../models/Translation');
const Product = require('../models/Product');
const logger = require('../utils/logger');
const { translateToMultipleLocales } = require('../services/translationService');

// 中间件：验证请求
const validate = (req, res, next) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ success: false, errors: errors.array() });
  }
  next();
};

// 辅助函数：安全地转换 locales Map 为对象
// 处理 Mongoose Map 类型在不同场景下的序列化格式
function convertLocalesToObject(locales) {
  if (!locales) {
    return {};
  }
  
  // 如果已经是普通对象（lean() 查询后的格式），直接返回
  if (typeof locales === 'object' && !(locales instanceof Map) && !Array.isArray(locales)) {
    // 检查是否有 Mongoose 内部属性（如 $__），如果没有则是普通对象
    if (!locales.hasOwnProperty('$__')) {
      return locales;
    }
    // 如果是 Mongoose 文档对象，尝试提取数据
    // 这种情况应该很少见，因为在 lean() 查询中不会出现
  }
  
  // 如果是 Map，转换为对象
  if (locales instanceof Map) {
    try {
      return Object.fromEntries(locales);
    } catch (e) {
      logger.warn('转换 Map 失败', { error: e.message });
      return {};
    }
  }
  
  // 如果是数组（可能是 [key, value] 格式或序列化后的格式）
  if (Array.isArray(locales)) {
    try {
      // 检查是否是键值对数组格式 [[key, value], ...]
      if (locales.length > 0 && Array.isArray(locales[0]) && locales[0].length === 2) {
        return Object.fromEntries(locales);
      }
      // 如果是普通数组，无法转换
      logger.warn('locales 数组格式不正确', { arrayLength: locales.length });
      return {};
    } catch (e) {
      logger.warn('转换数组失败', { error: e.message });
      return {};
    }
  }
  
  // 其他情况返回空对象
  return {};
}

// 创建词条
router.post('/',
  [
    body('key').notEmpty().withMessage('词条键不能为空'),
    body('namespace').optional().isString(),
    body('productId').notEmpty().withMessage('产品ID不能为空'),
    body('locales').optional().isObject().withMessage('多语言值必须是对象'),
    body('autoTranslate').optional().isBoolean().withMessage('autoTranslate必须是布尔值'),
    body('sourceText').optional().isString().withMessage('sourceText必须是字符串'),
    body('sourceLocale').optional().isString().withMessage('sourceLocale必须是字符串'),
  ],
  validate,
  async (req, res, next) => {
    try {
      const { key, namespace = 'common', productId, locales = {}, autoTranslate = false, sourceText, sourceLocale } = req.body;
      
      // 验证产品是否存在
      const product = await Product.findById(productId);
      if (!product) {
        return res.status(404).json({ success: false, message: '产品不存在' });
      }
      
      // 检查键是否已存在
      const existing = await Translation.findOne({
        productId,
        namespace,
        key,
        deleted: false
      });
      
      if (existing) {
        return res.status(409).json({ success: false, message: '词条键已存在' });
      }
      
      let finalLocales = { ...locales };
      
      // 如果启用自动翻译
      if (autoTranslate && sourceText && sourceLocale) {
        try {
          // 获取需要翻译的目标语言（排除源语言）
          const targetLocales = product.supportedLocales.filter(locale => locale !== sourceLocale);
          
          // 自动翻译到所有目标语言
          const translations = await translateToMultipleLocales(sourceText, sourceLocale, targetLocales);
          
          // 合并翻译结果
          finalLocales = {
            [sourceLocale]: sourceText, // 保持源文本
            ...translations
          };
          
          logger.info(`自动翻译完成: ${key}`, { 
            sourceLocale, 
            targetCount: targetLocales.length 
          });
        } catch (error) {
          logger.error('自动翻译失败', { error: error.message, key });
          // 翻译失败时，只保存源文本
          if (!finalLocales[sourceLocale]) {
            finalLocales[sourceLocale] = sourceText;
          }
        }
      }
      
      // 确保至少有一个语言的翻译
      if (Object.keys(finalLocales).length === 0) {
        return res.status(400).json({ 
          success: false, 
          message: '至少需要提供一个语言的翻译' 
        });
      }
      
      // 创建词条
      const translation = new Translation({
        key,
        namespace,
        productId,
        locales: new Map(Object.entries(finalLocales)),
        createdBy: req.user?.username || 'system'
      });
      
      await translation.save();
      
      logger.info(`词条已创建: ${key}`, { productId, namespace });
      
      res.status(201).json({
        success: true,
        data: {
          ...translation.toObject(),
          locales: convertLocalesToObject(translation.locales)
        }
      });
    } catch (error) {
      next(error);
    }
  }
);

// 查询词条列表
router.get('/',
  [
    query('productId').notEmpty().withMessage('产品ID不能为空'),
    query('namespace').optional(),
    query('status').optional().isIn(['draft', 'pending', 'approved', 'published']),
    query('locale').optional(),
    query('page').optional().isInt({ min: 1 }),
    query('limit').optional().isInt({ min: 1, max: 100 }),
  ],
  validate,
  async (req, res, next) => {
    try {
      const { productId, namespace, status, locale, page = 1, limit = 20 } = req.query;
      
      const filter = {
        productId,
        deleted: false
      };
      
      if (namespace) filter.namespace = namespace;
      if (status) filter.status = status;
      
      const skip = (parseInt(page) - 1) * parseInt(limit);
      
      const [translations, total] = await Promise.all([
        Translation.find(filter)
          .sort({ updatedAt: -1 })
          .skip(skip)
          .limit(parseInt(limit))
          .lean(),
        Translation.countDocuments(filter)
      ]);
      
      // 转换 locales Map 为对象
      const data = translations.map(t => {
        try {
          return {
            ...t,
            locales: convertLocalesToObject(t.locales)
          };
        } catch (error) {
          logger.error('转换词条 locales 失败', { 
            translationId: t._id, 
            error: error.message,
            localesType: typeof t.locales,
            localesIsMap: t.locales instanceof Map,
            localesIsArray: Array.isArray(t.locales)
          });
          // 即使转换失败，也返回词条，但 locales 为空对象
          return {
            ...t,
            locales: {}
          };
        }
      });
      
      res.json({
        success: true,
        data,
        pagination: {
          page: parseInt(page),
          limit: parseInt(limit),
          total,
          pages: Math.ceil(total / parseInt(limit))
        }
      });
    } catch (error) {
      next(error);
    }
  }
);

// 更新词条
router.put('/:id',
  [
    param('id').isMongoId().withMessage('无效的词条ID'),
    body('locales').optional().isObject(),
    body('status').optional().isIn(['draft', 'pending', 'approved', 'published']),
  ],
  validate,
  async (req, res, next) => {
    try {
      const translation = await Translation.findById(req.params.id);
      
      if (!translation || translation.deleted) {
        return res.status(404).json({ success: false, message: '词条不存在' });
      }
      
      // 更新多语言值
      if (req.body.locales) {
        Object.entries(req.body.locales).forEach(([locale, value]) => {
          translation.locales.set(locale, value);
        });
      }
      
      // 更新状态
      if (req.body.status && req.body.status !== translation.status) {
        await translation.updateStatus(
          req.body.status,
          req.user?.username,
          req.body.reviewNote
        );
      } else {
        await translation.save();
      }
      
      logger.info(`词条已更新: ${translation.key}`, { id: translation._id });
      
      res.json({
        success: true,
        data: {
          ...translation.toObject(),
          locales: convertLocalesToObject(translation.locales)
        }
      });
    } catch (error) {
      next(error);
    }
  }
);

// 删除词条 (软删除)
router.delete('/:id',
  [param('id').isMongoId().withMessage('无效的词条ID')],
  validate,
  async (req, res, next) => {
    try {
      const translation = await Translation.findById(req.params.id);
      
      if (!translation || translation.deleted) {
        return res.status(404).json({ success: false, message: '词条不存在' });
      }
      
      translation.deleted = true;
      await translation.save();
      
      logger.info(`词条已删除: ${translation.key}`, { id: translation._id });
      
      res.json({
        success: true,
        message: '词条已删除'
      });
    } catch (error) {
      next(error);
    }
  }
);

// 自动翻译API端点
router.post('/auto-translate',
  [
    body('text').notEmpty().withMessage('源文本不能为空'),
    body('fromLocale').notEmpty().withMessage('源语言不能为空'),
    body('toLocales').isArray().withMessage('目标语言必须是数组'),
  ],
  validate,
  async (req, res, next) => {
    try {
      const { text, fromLocale, toLocales } = req.body;
      
      const translations = await translateToMultipleLocales(text, fromLocale, toLocales);
      
      res.json({
        success: true,
        data: translations
      });
    } catch (error) {
      next(error);
    }
  }
);

module.exports = router;

